/**
 * 系统控制器
 * 处理系统级API请求
 */
const BaseController = require('../../../framework/controller/base_controller.js');
const BaseDataService = require('../service/base_data_service.js');
const AppError = require('../../../framework/core/app_error.js');

class SystemController extends BaseController {
  /**
   * 系统健康检查
   */
  async healthCheck() {
    console.log('[System] 执行系统健康检查');
    
    try {
      // 进行各项系统检查
      const checkResults = {
        database: await this._checkDatabase(),
        cache: await this._checkCache(),
        events: await this._checkEvents(),
        crossServices: await this._checkCrossServices()
      };
      
      // 判断整体健康状态
      const isHealthy = Object.values(checkResults).every(r => r.status === 'healthy');
      
      return this.success({
        status: isHealthy ? 'healthy' : 'unhealthy',
        components: checkResults,
        timestamp: new Date().toISOString(),
        version: this._getSystemVersion()
      });
    } catch (err) {
      console.error('[System] 健康检查异常:', err);
      return this.fail({
        status: 'error',
        error: err.message || '健康检查异常',
        timestamp: new Date().toISOString()
      });
    }
  }
  
  /**
   * 获取系统配置
   */
  async getConfig() {
    // 权限验证
    if (!await this.isAdmin()) {
      return this.fail('没有操作权限');
    }
    
    try {
      // 获取公共配置
      const config = {
        version: this._getSystemVersion(),
        projectIds: ['oa', 'plm', 'system'],
        apiVersion: 'v1',
        maxUploadSize: 50 * 1024 * 1024, // 50MB
        maxEventRetries: 3,
        cacheTimeout: 5 * 60, // 5分钟
        timezone: 'Asia/Shanghai',
        systemStatus: 'running'
      };
      
      return this.success(config);
    } catch (err) {
      console.error('[System] 获取配置异常:', err);
      return this.fail('获取系统配置失败');
    }
  }
  
  /**
   * 获取系统版本信息
   */
  async getVersion() {
    return this.success({
      version: this._getSystemVersion(),
      buildTime: '2025-04-30',
      environment: process.env.NODE_ENV || 'development'
    });
  }
  
  /**
   * 清除系统缓存
   */
  async clearCache() {
    // 权限验证
    if (!await this.isAdmin()) {
      return this.fail('没有操作权限');
    }
    
    try {
      // 清除基础数据缓存
      BaseDataService.clearCache();
      
      // 清除其他缓存
      // TODO: 添加其他缓存清理逻辑
      
      console.log('[System] 系统缓存已清除');
      
      return this.success({
        result: 'ok',
        timestamp: new Date().toISOString()
      });
    } catch (err) {
      console.error('[System] 清除缓存异常:', err);
      return this.fail('清除系统缓存失败');
    }
  }
  
  /**
   * 检查数据库连接
   * @returns {Promise<Object>} 检查结果
   */
  async _checkDatabase() {
    try {
      const db = wx.cloud.database();
      
      // 执行一个简单查询测试数据库连接
      await db.collection('system_config').limit(1).get();
      
      return {
        status: 'healthy',
        message: '数据库连接正常'
      };
    } catch (err) {
      console.error('[System] 数据库检查失败:', err);
      return {
        status: 'unhealthy',
        message: '数据库连接异常',
        error: err.message
      };
    }
  }
  
  /**
   * 检查缓存状态
   * @returns {Promise<Object>} 检查结果
   */
  async _checkCache() {
    try {
      // 测试缓存服务
      const users = await BaseDataService.getAllUsers();
      
      return {
        status: 'healthy',
        message: '缓存服务正常',
        count: users ? users.length : 0
      };
    } catch (err) {
      console.error('[System] 缓存检查失败:', err);
      return {
        status: 'unhealthy',
        message: '缓存服务异常',
        error: err.message
      };
    }
  }
  
  /**
   * 检查事件系统
   * @returns {Promise<Object>} 检查结果
   */
  async _checkEvents() {
    try {
      // 加载事件模型
      const EventModel = require('../config/models_config').event_model;
      const eventModel = new EventModel();
      
      // 检查事件模型
      await eventModel.getPendingEvents({ limit: 1 });
      
      return {
        status: 'healthy',
        message: '事件系统正常'
      };
    } catch (err) {
      console.error('[System] 事件系统检查失败:', err);
      return {
        status: 'unhealthy',
        message: '事件系统异常',
        error: err.message
      };
    }
  }
  
  /**
   * 检查跨项目服务
   * @returns {Promise<Object>} 检查结果
   */
  async _checkCrossServices() {
    try {
      // 检查全局跨项目服务是否已注册
      if (!global.CROSS_SERVICE) {
        return {
          status: 'unhealthy',
          message: '跨项目服务未初始化'
        };
      }
      
      // 检查各项目服务
      const serviceStatus = {
        oa: !!global.CROSS_SERVICE.OA,
        plm: !!global.CROSS_SERVICE.PLM
      };
      
      // 至少有一个服务可用即为健康
      const isHealthy = Object.values(serviceStatus).some(status => status);
      
      return {
        status: isHealthy ? 'healthy' : 'unhealthy',
        message: isHealthy ? '跨项目服务正常' : '所有跨项目服务不可用',
        services: serviceStatus
      };
    } catch (err) {
      console.error('[System] 跨项目服务检查失败:', err);
      return {
        status: 'unhealthy',
        message: '跨项目服务检查异常',
        error: err.message
      };
    }
  }
  
  /**
   * 获取系统版本
   * @returns {String} 系统版本号
   */
  _getSystemVersion() {
    // 实际项目中应从配置或环境变量获取
    return '1.0.0';
  }
}

module.exports = SystemController; 